public async Task SwaggerOperationMethods_AreParsed()
{
//// Arrange
var generator = new AspNetCoreToSwaggerGenerator(new AspNetCoreToSwaggerGeneratorSettings());
var apiDescriptions = GetApiDescriptionGroups(typeof(HttpMethodsController));
//// Act
var document = await generator.GenerateAsync(apiDescriptions);
//// Assert
Assert.Collection(
document.Operations.OrderBy(o => o.Method.ToString()),
operation =>
{
Assert.Equal(SwaggerOperationMethod.Delete, operation.Method);
Assert.Equal("HttpMethods_HttpDelete", operation.Operation.OperationId);
},
operation =>
{
Assert.Equal(SwaggerOperationMethod.Head, operation.Method);
Assert.Equal("HttpMethods_HttpHead", operation.Operation.OperationId);
},
operation =>
{
Assert.Equal(SwaggerOperationMethod.Options, operation.Method);
Assert.Equal("HttpMethods_HttpOptions", operation.Operation.OperationId);
},
operation =>
{
Assert.Equal(SwaggerOperationMethod.Patch, operation.Method);
Assert.Equal("HttpMethods_HttpPatch", operation.Operation.OperationId);
});
}
public async Task ComplexQueryParametersAreProcessed()
{
//// Arrange
var generator = new AspNetCoreToSwaggerGenerator(new AspNetCoreToSwaggerGeneratorSettings());
var apiDescriptions = GetApiDescriptionGroups(typeof(ControllerWithParameters));
//// Act
var document = await generator.GenerateAsync(apiDescriptions);
//// Assert
var operation = Assert.Single(document.Operations, o => o.Path == "/" + nameof(ControllerWithParameters.ComplexFromQueryParameter)).Operation;
Assert.Collection(
operation.Parameters.OrderBy(p => p.Name),
parameter =>
{
Assert.Equal(nameof(ComplexModel.Header), parameter.Name);
Assert.Equal(SwaggerParameterKind.Query, parameter.Kind);
},
parameter =>
{
Assert.Equal(nameof(ComplexModel.Id), parameter.Name);
Assert.Equal(SwaggerParameterKind.Query, parameter.Kind);
},
parameter =>
{
Assert.Equal(nameof(ComplexModel.QueryValues), parameter.Name);
Assert.Equal(SwaggerParameterKind.Query, parameter.Kind);
});
}
public async Task When_generating_swagger_all_apidescriptions_are_discovered()
{
//// Arrange
var generator = new AspNetCoreToSwaggerGenerator(new AspNetCoreToSwaggerGeneratorSettings());
var apiDescriptions = GetApiDescriptionGroups(typeof(TestController));
//// Act
var document = await generator.GenerateAsync(apiDescriptions);
//// Assert
var operationDescription = Assert.Single(document.Operations);
Assert.Equal("/test", operationDescription.Path);
Assert.Equal(SwaggerOperationMethod.Get, operationDescription.Method);
var operation = operationDescription.Operation;
Assert.Equal("Test_FindModel", operation.OperationId);
var parameter = Assert.Single(operation.Parameters);
Assert.Equal("id", parameter.Name);
Assert.Equal(SwaggerParameterKind.Path, parameter.Kind);
Assert.True(parameter.IsRequired);
Assert.Equal(NJsonSchema.JsonObjectType.Integer, parameter.Type);
Assert.Single(operation.Responses);
var response = operation.Responses["200"];
var definition = document.Definitions.First(f => f.Value == response.GetActualResponseSchema(operation));
Assert.Equal(nameof(TestModel), definition.Key);
}
protected override async Task <string> RunIsolatedAsync(AssemblyLoader.AssemblyLoader assemblyLoader)
{
Settings.DocumentTemplate = await GetDocumentTemplateAsync();
InitializeCustomTypes(assemblyLoader);
var previousWorkingDirectory = ChangeWorkingDirectory();
using (var testServer = await CreateTestServerAsync(assemblyLoader))
{
// See https://github.com/aspnet/Mvc/issues/5690
var type = typeof(IApiDescriptionGroupCollectionProvider);
var apiDescriptionProvider = (IApiDescriptionGroupCollectionProvider)testServer.Host.Services.GetRequiredService(type);
var settings = await CreateSettingsAsync(assemblyLoader, testServer.Host);
var generator = new AspNetCoreToSwaggerGenerator(settings);
var document = await generator.GenerateAsync(apiDescriptionProvider.ApiDescriptionGroups).ConfigureAwait(false);
var json = PostprocessDocument(document);
Directory.SetCurrentDirectory(previousWorkingDirectory);
return(json);
}
}
private AspNetCoreOperationProcessorContext GetContext(ApiDescription apiDescription)
{
var operationDescription = new SwaggerOperationDescription {
Operation = new SwaggerOperation()
};
var swaggerSettings = new AspNetCoreToSwaggerGeneratorSettings();
var document = new SwaggerDocument();
var generator = new AspNetCoreToSwaggerGenerator(swaggerSettings);
var schemaGeneratorSettings = new JsonSchemaGeneratorSettings();
var schemaGenerator = new JsonSchemaGenerator(schemaGeneratorSettings);
var schemaResolver = new SwaggerSchemaResolver(document, schemaGeneratorSettings);
var context = new AspNetCoreOperationProcessorContext(
document,
operationDescription,
GetType(),
GetType().GetMethod(nameof(SomeAction), BindingFlags.NonPublic | BindingFlags.Instance),
new SwaggerGenerator(schemaGenerator, schemaGeneratorSettings, schemaResolver),
schemaGenerator,
schemaResolver,
swaggerSettings,
new List <SwaggerOperationDescription>())
{
ApiDescription = apiDescription,
};
return(context);
}
protected override async Task <string> RunIsolatedAsync(AssemblyLoader.AssemblyLoader assemblyLoader)
{
Settings.DocumentTemplate = await GetDocumentTemplateAsync();
InitializeCustomTypes(assemblyLoader);
var previousWorkingDirectory = ChangeWorkingDirectory();
var assemblies = await LoadAssembliesAsync(AssemblyPaths, assemblyLoader).ConfigureAwait(false);
var startupType = assemblies.First().ExportedTypes.First(t => t.Name == "Startup"); // TODO: Use .NET Core startup lookup or provide setting
using (var testServer = new TestServer(new WebHostBuilder().UseStartup(startupType)))
{
// See https://github.com/aspnet/Mvc/issues/5690
var type = typeof(IApiDescriptionGroupCollectionProvider);
var apiDescriptionProvider = (IApiDescriptionGroupCollectionProvider)testServer.Host.Services.GetRequiredService(type);
var generator = new AspNetCoreToSwaggerGenerator(Settings);
var document = await generator.GenerateAsync(apiDescriptionProvider.ApiDescriptionGroups).ConfigureAwait(false);
var json = PostprocessDocument(document);
Directory.SetCurrentDirectory(previousWorkingDirectory);
return(json);
}
}
public async Task BoundPropertiesAreProcessed()
{
//// Arrange
var generator = new AspNetCoreToSwaggerGenerator(new AspNetCoreToSwaggerGeneratorSettings());
var apiDescriptions = GetApiDescriptionGroups(typeof(ControllerWithBoundProperties));
//// Act
var document = await generator.GenerateAsync(apiDescriptions);
//// Assert
var operation = Assert.Single(document.Operations).Operation;
Assert.Collection(
operation.Parameters.OrderBy(p => p.Name),
parameter =>
{
Assert.Equal(nameof(ControllerWithBoundProperties.HeaderValue), parameter.Name);
Assert.Equal(SwaggerParameterKind.Header, parameter.Kind);
},
parameter =>
{
Assert.Equal(nameof(ControllerWithBoundProperties.Id), parameter.Name);
Assert.Equal(SwaggerParameterKind.Path, parameter.Kind);
},
parameter =>
{
Assert.Equal("model", parameter.Name);
Assert.Equal(SwaggerParameterKind.Body, parameter.Kind);
});
}
/// <summary>Occurs after the action method is invoked.</summary>
/// <param name="context">The action executed context.</param>
public override void OnActionExecuted(ActionExecutedContext context)
{
if (context.Exception != null && (_exceptionTypes.Count == 0 || _exceptionTypes.Exists(t => t.IsInstanceOfType(context.Exception))))
{
var settings = AspNetCoreToSwaggerGenerator.GetJsonSerializerSettings(context.HttpContext?.RequestServices);
settings = settings != null?CopySettings(settings) : new JsonSerializerSettings();
settings.Converters.Add(new JsonExceptionConverter(_hideStackTrace, _searchedNamespaces));
var json = JsonConvert.SerializeObject(context.Exception, settings);
context.Result = new ContentResult
{
StatusCode = GetStatusCode(context.Exception, context),
Content = json,
ContentType = "application/json"
};
// Required otherwise the framework exception handlers ignores the
// Result and redirects to a error page or displays in dev mode the stack trace.
context.ExceptionHandled = true;
}
else
{
base.OnActionExecuted(context);
}
}
/// <summary>Generates the Swagger specification.</summary>
/// <param name="context">The context.</param>
/// <returns>The Swagger specification.</returns>
protected virtual async Task <string> GenerateSwaggerAsync(HttpContext context)
{
var apiDescriptionGroups = _apiDescriptionGroupCollectionProvider.ApiDescriptionGroups;
if (apiDescriptionGroups.Version == Volatile.Read(ref _version) && _swaggerJson != null)
{
return(_swaggerJson);
}
try
{
var generator = new AspNetCoreToSwaggerGenerator(_settings, _schemaGenerator);
var document = await generator.GenerateAsync(apiDescriptionGroups);
document.Host = context.Request.Host.Value ?? "";
document.Schemes.Add(context.Request.Scheme == "http" ? SwaggerSchema.Http : SwaggerSchema.Https);
document.BasePath = context.Request.PathBase.Value?.Substring(0, context.Request.PathBase.Value.Length - (_settings.MiddlewareBasePath?.Length ?? 0)) ?? "";
_settings.PostProcess?.Invoke(document);
_swaggerJson = document.ToJson();
_version = apiDescriptionGroups.Version;
}
catch (Exception exception)
{
_swaggerJson = exception.ToString();
}
return(_swaggerJson);
}
public async Task QueryParametersAreDiscovered()
{
//// Arrange
var generator = new AspNetCoreToSwaggerGenerator(new AspNetCoreToSwaggerGeneratorSettings {
RequireParametersWithoutDefault = true
});
var apiDescriptions = GetApiDescriptionGroups(typeof(ControllerWithParameters));
//// Act
var document = await generator.GenerateAsync(apiDescriptions);
//// Assert
var operation = Assert.Single(document.Operations, o => o.Path == "/" + nameof(ControllerWithParameters.QueryParameter)).Operation;
var requiredParameter = operation.Parameters.First();
var optionalParameter = operation.Parameters.Last();
Assert.Equal(SwaggerParameterKind.Query, requiredParameter.Kind);
Assert.Equal(SwaggerParameterKind.Query, optionalParameter.Kind);
Assert.Equal("queryParameter1", requiredParameter.Name);
Assert.Equal("queryParameter2", optionalParameter.Name);
Assert.True(requiredParameter.IsRequired);
Assert.False(optionalParameter.IsRequired);
}
protected async Task <SwaggerDocument> GenerateDocumentAsync(AspNetCoreToSwaggerGeneratorSettings settings)
{
var generator = new AspNetCoreToSwaggerGenerator(settings);
var provider = TestServer.Host.Services.GetRequiredService <IApiDescriptionGroupCollectionProvider>();
var document = await generator.GenerateAsync(provider.ApiDescriptionGroups);
return(document);
}
/// <summary>Adds a document to the registry.</summary>
/// <param name="registry">The registry.</param>
/// <param name="configure">The configure action.</param>
/// <returns>The registry.</returns>
public static ISwaggerDocumentBuilder AddSwaggerDocument(this ISwaggerDocumentBuilder registry, Action <SwaggerDocumentSettings> configure = null)
{
var settings = new SwaggerDocumentSettings();
settings.SchemaType = SchemaType.Swagger2;
configure?.Invoke(settings);
var generator = new AspNetCoreToSwaggerGenerator(settings, settings.SchemaGenerator ?? new SwaggerJsonSchemaGenerator(settings));
return(((SwaggerDocumentRegistry)registry).AddDocument(settings.DocumentName, generator));
}
public async Task SwaggerOperationProcessorAttributesOnActions_AreDiscoveredAndExecuted()
{
//// Arrange
var generator = new AspNetCoreToSwaggerGenerator(new AspNetCoreToSwaggerGeneratorSettings());
var apiDescriptions = GetApiDescriptionGroups(typeof(ActionWithSwaggerOperationProcessor));
//// Act
var document = await generator.GenerateAsync(apiDescriptions);
//// Assert
Assert.Equal("Hello from action", document.Info.Title);
}
public async Task ControllersWithSwaggerIgnoreAttribute_AreIgnored()
{
//// Arrange
var generator = new AspNetCoreToSwaggerGenerator(new AspNetCoreToSwaggerGeneratorSettings());
var apiDescriptions = GetApiDescriptionGroups(typeof(ControllerWithSwaggerIgnoreAttribute));
//// Act
var document = await generator.GenerateAsync(apiDescriptions);
//// Assert
Assert.Empty(document.Operations);
}
/// <summary>Generates the Swagger specification.</summary>
/// <param name="context">The context.</param>
/// <returns>The Swagger specification.</returns>
protected virtual async Task <string> GenerateSwaggerAsync(HttpContext context)
{
if (_schemaException != null && _schemaTimestamp + _settings.ExceptionCacheTime > DateTimeOffset.UtcNow)
{
throw _schemaException;
}
var apiDescriptionGroups = _apiDescriptionGroupCollectionProvider.ApiDescriptionGroups;
if (apiDescriptionGroups.Version == Volatile.Read(ref _version) && _schemaJson != null)
{
return(_schemaJson);
}
try
{
// TODO: Move to NJS (same in other generator)
var isSerializerSettingsSpecified =
_settings.GeneratorSettings.DefaultPropertyNameHandling != PropertyNameHandling.Default ||
_settings.GeneratorSettings.DefaultEnumHandling != EnumHandling.Integer ||
_settings.GeneratorSettings.ContractResolver != null |
_settings.GeneratorSettings.SerializerSettings != null;
if (!isSerializerSettingsSpecified)
{
_settings.GeneratorSettings.SerializerSettings = _mvcJsonOptions.Value.SerializerSettings;
}
var generator = new AspNetCoreToSwaggerGenerator(_settings.GeneratorSettings, _schemaGenerator);
var document = await generator.GenerateAsync(apiDescriptionGroups);
document.Host = context.Request.Host.Value ?? "";
document.Schemes.Add(context.Request.Scheme == "http" ? SwaggerSchema.Http : SwaggerSchema.Https);
document.BasePath = context.Request.PathBase.Value?.Substring(0, context.Request.PathBase.Value.Length - (_settings.MiddlewareBasePath?.Length ?? 0)) ?? "";
_settings.PostProcess?.Invoke(document);
_schemaJson = document.ToJson();
_schemaException = null;
_version = apiDescriptionGroups.Version;
_schemaTimestamp = DateTimeOffset.UtcNow;
}
catch (Exception exception)
{
_schemaJson = null;
_schemaException = exception;
_schemaTimestamp = DateTimeOffset.UtcNow;
throw _schemaException;
}
return(_schemaJson);
}
protected async Task <SwaggerDocument> GenerateDocumentAsync(AspNetCoreToSwaggerGeneratorSettings settings, params Type[] controllerTypes)
{
var generator = new AspNetCoreToSwaggerGenerator(settings);
var provider = TestServer.Host.Services.GetRequiredService <IApiDescriptionGroupCollectionProvider>();
var controllerTypeNames = controllerTypes.Select(t => t.FullName);
var groups = new ApiDescriptionGroupCollection(provider.ApiDescriptionGroups.Items
.Select(i => new ApiDescriptionGroup(i.GroupName, i.Items.Where(u => controllerTypeNames.Contains(((ControllerActionDescriptor)u.ActionDescriptor).ControllerTypeInfo.FullName)).ToList())).ToList(),
provider.ApiDescriptionGroups.Version);
var document = await generator.GenerateAsync(groups);
return(document);
}
public async Task SwaggerOperationAttribute_AreUsedToCalculateOperationId_IfPresent()
{
//// Arrange
var generator = new AspNetCoreToSwaggerGenerator(new AspNetCoreToSwaggerGeneratorSettings());
var apiDescriptions = GetApiDescriptionGroups(typeof(ActionWithSwaggerOperationAttribute));
//// Act
var document = await generator.GenerateAsync(apiDescriptions);
//// Assert
var operation = Assert.Single(document.Operations);
Assert.Equal("CustomOperationId", operation.Operation.OperationId);
}
public static void Process(string commandContent, string outputFile, string applicationName)
{
var serviceProvider = GetServiceProvider(applicationName);
var apiDescriptionProvider = serviceProvider.GetRequiredService <IApiDescriptionGroupCollectionProvider>();
var settings = CreateSettings(commandContent);
var swaggerGenerator = new AspNetCoreToSwaggerGenerator(settings);
var swaggerDocument = swaggerGenerator.GenerateAsync(apiDescriptionProvider.ApiDescriptionGroups).GetAwaiter().GetResult();
var outputPathDirectory = Path.GetDirectoryName(outputFile);
Directory.CreateDirectory(outputPathDirectory);
File.WriteAllText(outputFile, swaggerDocument.ToJson());
}
public async Task ActionsWithSwaggerIgnoreAttribute_AreIgnored()
{
//// Arrange
var generator = new AspNetCoreToSwaggerGenerator(new AspNetCoreToSwaggerGeneratorSettings());
var apiDescriptions = GetApiDescriptionGroups(typeof(ActionWithSwaggerIgnoreAttribute));
//// Act
var document = await generator.GenerateAsync(apiDescriptions);
//// Assert
var operationDescription = Assert.Single(document.Operations);
Assert.Equal("/test1", operationDescription.Path);
Assert.Equal(SwaggerOperationMethod.Get, operationDescription.Method);
}
public async Task FormFileParametersAreDiscovered()
{
//// Arrange
var generator = new AspNetCoreToSwaggerGenerator(new AspNetCoreToSwaggerGeneratorSettings());
var apiDescriptions = GetApiDescriptionGroups(typeof(ControllerWithParameters));
//// Act
var document = await generator.GenerateAsync(apiDescriptions);
//// Assert
var operation = Assert.Single(document.Operations, o => o.Path == "/" + nameof(ControllerWithParameters.FileParameter)).Operation;
var parameter = Assert.Single(operation.Parameters);
Assert.Equal(SwaggerParameterKind.FormData, parameter.Kind);
Assert.Equal("multipart/form-data", Assert.Single(operation.Consumes));
}
/// <summary>Adds services required for Swagger 2.0 generation (change document settings to generate OpenAPI 3.0).</summary>
/// <param name="serviceCollection">The <see cref="IServiceCollection"/>.</param>
/// <param name="configure">Configure the document.</param>
public static IServiceCollection AddSwaggerDocument(this IServiceCollection serviceCollection, Action <SwaggerDocumentSettings, IServiceProvider> configure = null)
{
serviceCollection.AddSingleton(services =>
{
var settings = new SwaggerDocumentSettings();
settings.SchemaType = SchemaType.Swagger2;
configure?.Invoke(settings, services);
if (settings.PostProcess != null)
{
var processor = new ActionDocumentProcessor(context => settings.PostProcess(context.Document));
settings.DocumentProcessors.Add(processor);
}
foreach (var documentProcessor in services.GetRequiredService <IEnumerable <IDocumentProcessor> >())
{
settings.DocumentProcessors.Add(documentProcessor);
}
foreach (var operationProcessor in services.GetRequiredService <IEnumerable <IOperationProcessor> >())
{
settings.OperationProcessors.Add(operationProcessor);
}
var schemaGenerator = settings.SchemaGenerator ?? new SwaggerJsonSchemaGenerator(settings);
var generator = new AspNetCoreToSwaggerGenerator(settings, schemaGenerator);
return(new SwaggerDocumentRegistration(settings.DocumentName, generator));
});
var descriptor = serviceCollection.SingleOrDefault(d => d.ServiceType == typeof(SwaggerDocumentProvider));
if (descriptor == null)
{
serviceCollection.AddSingleton <SwaggerDocumentProvider>();
serviceCollection.AddSingleton <IConfigureOptions <MvcOptions>, SwaggerConfigureMvcOptions>();
// Used by UseDocumentProvider CLI setting
serviceCollection.AddSingleton <ISwaggerDocumentProvider>(s => s.GetRequiredService <SwaggerDocumentProvider>());
// Used by the Microsoft.Extensions.ApiDescription tool
serviceCollection.AddSingleton <ApiDescription.IDocumentProvider>(s => s.GetRequiredService <SwaggerDocumentProvider>());
}
return(serviceCollection);
}
public async Task When_no_IncludedVersions_are_defined_then_all_routes_are_available_and_replaced()
{
//// Arrange
var generator = new AspNetCoreToSwaggerGenerator(new AspNetCoreToSwaggerGeneratorSettings());
var apiDescriptions = GetApiDescriptionGroups(typeof(ControllerWithReCodeAttribute));
//// Act
var document = await generator.GenerateAsync(apiDescriptions);
//// Assert
var operation = Assert.Single(document.Operations).Operation;
Assert.True(operation.ExtensionData.ContainsKey("x-code-samples"));
var extenstionData = (IList <ReDocCodeSampleAttribute.ReDocCodeSample>)operation.ExtensionData["x-code-samples"];
Assert.Equal(2, extenstionData.Count);
}
public async Task FromBodyParametersAreDiscovered()
{
//// Arrange
var generator = new AspNetCoreToSwaggerGenerator(new AspNetCoreToSwaggerGeneratorSettings());
var apiDescriptions = GetApiDescriptionGroups(typeof(ControllerWithParameters));
//// Act
var document = await generator.GenerateAsync(apiDescriptions);
//// Assert
var operation = Assert.Single(document.Operations, o => o.Path == "/" + nameof(ControllerWithParameters.FromBodyParameter)).Operation;
var parameter = Assert.Single(operation.Parameters);
Assert.Equal(SwaggerParameterKind.Body, parameter.Kind);
Assert.Equal("model", parameter.Name);
Assert.True(parameter.IsRequired);
}
public async Task SwaggerResponseAttributesOnActionsAreDiscovered()
{
//// Arrange
var generator = new AspNetCoreToSwaggerGenerator(new AspNetCoreToSwaggerGeneratorSettings());
var apiDescriptions = GetApiDescriptionGroups(typeof(ActionWithSwaggerResponseAttribute));
//// Act
var document = await generator.GenerateAsync(apiDescriptions);
//// Assert
var operation = Assert.Single(document.Operations);
Assert.Single(operation.Operation.Responses);
var response = operation.Operation.Responses["201"];
var definition = document.Definitions.First(f => f.Value == response.GetActualResponseSchema(operation.Operation));
Assert.Equal(nameof(TestModel), definition.Key);
}
public async Task When_generating_v2_then_only_v2_operations_are_included()
{
// Arrange
var settings = new AspNetCoreToSwaggerGeneratorSettings();
settings.OperationProcessors.TryGet <ApiVersionProcessor>().IncludedVersions = new[] { "2" };
var generator = new AspNetCoreToSwaggerGenerator(settings);
var provider = _testServer.Host.Services.GetRequiredService <IApiDescriptionGroupCollectionProvider>();
// Act
var document = await generator.GenerateAsync(provider.ApiDescriptionGroups);
var json = document.ToJson();
// Assert
Assert.Equal(2, document.Operations.Count());
Assert.True(document.Operations.All(o => o.Path.Contains("/v2/")));
}
public async Task ParametersWithSwaggerIgnoreAttribute_AreIgnored()
{
//// Arrange
var generator = new AspNetCoreToSwaggerGenerator(new AspNetCoreToSwaggerGeneratorSettings());
var apiDescriptions = GetApiDescriptionGroups(typeof(ParameterWithSwaggerIgnoreAttribute));
//// Act
var document = await generator.GenerateAsync(apiDescriptions);
//// Assert
var operationDescription = Assert.Single(document.Operations);
Assert.Equal("/{id}", operationDescription.Path);
Assert.Equal(SwaggerOperationMethod.Post, operationDescription.Method);
var parameter = Assert.Single(operationDescription.Operation.Parameters);
Assert.Equal("id", parameter.Name);
Assert.Equal(SwaggerParameterKind.Path, parameter.Kind);
}
/// <summary>Generates the Swagger specification.</summary>
/// <param name="context">The context.</param>
/// <returns>The Swagger specification.</returns>
protected virtual async Task <string> GenerateSwaggerAsync(HttpContext context)
{
if (_schemaException != null && _schemaTimestamp + _settings.ExceptionCacheTime > DateTimeOffset.UtcNow)
{
throw _schemaException;
}
var apiDescriptionGroups = _apiDescriptionGroupCollectionProvider.ApiDescriptionGroups;
if (apiDescriptionGroups.Version == Volatile.Read(ref _version) && _schemaJson != null)
{
return(_schemaJson);
}
try
{
var serializerSettings = _mvcJsonOptions.Value.SerializerSettings;
var settings = _settings.CreateGeneratorSettings(serializerSettings);
var generator = new AspNetCoreToSwaggerGenerator(settings, _schemaGenerator);
var document = await generator.GenerateAsync(apiDescriptionGroups);
document.Host = context.Request.Host.Value ?? "";
document.Schemes.Add(context.Request.Scheme == "http" ? SwaggerSchema.Http : SwaggerSchema.Https);
document.BasePath = context.Request.PathBase.Value?.Substring(0, context.Request.PathBase.Value.Length - (_settings.MiddlewareBasePath?.Length ?? 0)) ?? "";
_settings.PostProcess?.Invoke(document);
_schemaJson = document.ToJson();
_schemaException = null;
_version = apiDescriptionGroups.Version;
_schemaTimestamp = DateTimeOffset.UtcNow;
}
catch (Exception exception)
{
_schemaJson = null;
_schemaException = exception;
_schemaTimestamp = DateTimeOffset.UtcNow;
throw _schemaException;
}
return(_schemaJson);
}
public static void Process(string commandContent, string outputFile, string applicationName)
{
var serviceProvider = GetServiceProvider(applicationName);
var apiDescriptionProvider = serviceProvider.GetRequiredService <IApiDescriptionGroupCollectionProvider>();
var assemblyLoader = new AssemblyLoader.AssemblyLoader();
var command = JsonConvert.DeserializeObject <AspNetCoreToSwaggerCommand>(commandContent);
command.InitializeCustomTypes(assemblyLoader);
var generator = new AspNetCoreToSwaggerGenerator(command.Settings);
var document = generator.GenerateAsync(apiDescriptionProvider.ApiDescriptionGroups).GetAwaiter().GetResult();
command.PostprocessDocument(document);
var outputPathDirectory = Path.GetDirectoryName(outputFile);
Directory.CreateDirectory(outputPathDirectory);
File.WriteAllText(outputFile, document.ToJson());
}
public static void Process(string commandContent, string outputFile, string applicationName)
{
var command = JsonConvert.DeserializeObject <AspNetCoreToSwaggerCommand>(commandContent);
var previousWorkingDirectory = command.ChangeWorkingDirectory();
var webHost = GetWebHost(applicationName);
var apiDescriptionProvider = webHost.Services.GetRequiredService <IApiDescriptionGroupCollectionProvider>();
var assemblyLoader = new AssemblyLoader.AssemblyLoader();
var settings = Task.Run(async() => await command.CreateSettingsAsync(assemblyLoader, webHost)).GetAwaiter().GetResult();
var generator = new AspNetCoreToSwaggerGenerator(settings);
var document = generator.GenerateAsync(apiDescriptionProvider.ApiDescriptionGroups).GetAwaiter().GetResult();
var json = command.PostprocessDocument(document);
Directory.SetCurrentDirectory(previousWorkingDirectory);
var outputPathDirectory = Path.GetDirectoryName(outputFile);
Directory.CreateDirectory(outputPathDirectory);
File.WriteAllText(outputFile, json);
}
public async Task SwaggerDocumentIsGeneratedForCustomCreatedApiDescriptions()
{
//// Arrange
var generator = new AspNetCoreToSwaggerGenerator(new AspNetCoreToSwaggerGeneratorSettings());
var apiDescriptions = new[]
{
new ApiDescription
{
ActionDescriptor = new ActionDescriptor(),
},
new ApiDescription
{
ActionDescriptor = new ControllerActionDescriptor
{
ControllerTypeInfo = typeof(CustomController).GetTypeInfo(),
MethodInfo = typeof(CustomController).GetMethod(nameof(CustomController.FindModel)),
AttributeRouteInfo = new AttributeRouteInfo
{
Template = "api/test/{id}",
},
ControllerName = "Test",
ActionName = "Find",
},
HttpMethod = "Get",
RelativePath = "api/test/{id}",
ParameterDescriptions =
{
new ApiParameterDescription
{
Name = "id",
Source = BindingSource.Path,
Type = typeof(int),
},
},
SupportedResponseTypes =
{
new ApiResponseType
{
Type = typeof(TestModel),
StatusCode = 200,
}
},
},
new ApiDescription
{
ActionDescriptor = new ControllerActionDescriptor
{
ControllerTypeInfo = typeof(CustomController).GetTypeInfo(),
MethodInfo = typeof(CustomController).GetMethod(nameof(CustomController.Delete)),
ControllerName = "Test",
ActionName = "DeleteModel",
},
HttpMethod = "Delete",
RelativePath = "api/test",
ParameterDescriptions =
{
new ApiParameterDescription
{
Name = "id",
Source = BindingSource.Query,
Type = typeof(int),
},
},
SupportedResponseTypes =
{
new ApiResponseType
{
Type = typeof(StatusCodeResult),
StatusCode = 201,
}
},
},
new ApiDescription
{
ActionDescriptor = new ControllerActionDescriptor
{
ControllerTypeInfo = typeof(CustomController).GetTypeInfo(),
MethodInfo = typeof(CustomController).GetMethod(nameof(CustomController.Update)),
AttributeRouteInfo = new AttributeRouteInfo
{
Template = "api/test/{id}",
},
ControllerName = "Test",
ActionName = "Update",
},
HttpMethod = "Put",
RelativePath = "api/test/{id}",
ParameterDescriptions =
{
new ApiParameterDescription
{
Type = typeof(int),
Name = "id",
Source = BindingSource.Path,
},
new ApiParameterDescription
{
Type = typeof(TestModel),
Name = "model",
Source = BindingSource.Body,
},
},
SupportedResponseTypes =
{
new ApiResponseType
{
Type = typeof(Task <TestModel>),
StatusCode = 200,
}
},
},
};
var apiDescriptionGroupCollection = new ApiDescriptionGroupCollection(
new[] { new ApiDescriptionGroup(string.Empty, apiDescriptions) },
version: 1);
//// Act
var document = await generator.GenerateAsync(apiDescriptionGroupCollection);
//// Assert
Assert.Collection(
document.Operations.OrderBy(o => o.Method.ToString()),
operation =>
{
Assert.Equal("/api/test", operation.Path);
Assert.Equal(SwaggerOperationMethod.Delete, operation.Method);
},
operation =>
{
Assert.Equal("/api/test/{id}", operation.Path);
Assert.Equal(SwaggerOperationMethod.Get, operation.Method);
Assert.Single(operation.Operation.Responses);
var response = operation.Operation.Responses["200"];
var definition = document.Definitions.First(f => f.Value == response.GetActualResponseSchema(operation.Operation));
Assert.Equal(nameof(TestModel), definition.Key);
},
operation =>
{
Assert.Equal("/api/test/{id}", operation.Path);
Assert.Equal(SwaggerOperationMethod.Put, operation.Method);
});
}
