public void CreateResponseForEdmActionReturnCorrectResponses(string actionName, bool isActionImport)
{
// Arrange
IEdmModel model = EdmModelHelper.TripServiceModel;
ODataContext context = new ODataContext(model);
// Act
OpenApiResponses responses;
if (isActionImport)
{
IEdmOperationImport operationImport = model.EntityContainer.OperationImports().First(o => o.Name == actionName);
Assert.NotNull(operationImport); // guard
responses = context.CreateResponses(operationImport);
}
else
{
IEdmOperation operation = model.SchemaElements.OfType <IEdmOperation>().First(o => o.Name == actionName);
Assert.NotNull(operation); // guard
responses = context.CreateResponses(operation);
}
// Assert
Assert.NotNull(responses);
Assert.NotEmpty(responses);
Assert.Equal(2, responses.Count);
Assert.Equal(new string[] { "204", "default" }, responses.Select(r => r.Key));
}
public void CreateResponseForEdmFunctionReturnCorrectResponses(bool isFunctionImport, OpenApiSpecVersion specVersion)
{
// Arrange
string operationName = "GetPersonWithMostFriends";
IEdmModel model = EdmModelHelper.TripServiceModel;
ODataContext context = new ODataContext(model);
context.Settings.OpenApiSpecVersion = specVersion;
// Act
OpenApiResponses responses;
if (isFunctionImport)
{
IEdmOperationImport operationImport = model.EntityContainer.OperationImports().First(o => o.Name == operationName);
Assert.NotNull(operationImport); // guard
responses = context.CreateResponses(operationImport);
}
else
{
IEdmOperation operation = model.SchemaElements.OfType <IEdmOperation>().First(o => o.Name == operationName);
Assert.NotNull(operation); // guard
responses = context.CreateResponses(operation);
}
// Assert
Assert.NotNull(responses);
Assert.NotEmpty(responses);
Assert.Equal(2, responses.Count);
Assert.Equal(new string[] { "200", "default" }, responses.Select(r => r.Key));
OpenApiResponse response = responses["200"];
Assert.NotNull(response.Content);
OpenApiMediaType mediaType = response.Content["application/json"];
// For either version, nullable should be set
// and the serializer will ignore for v2
Assert.True(mediaType.Schema.Nullable);
// openApi version 2 should have not use nullable
if (specVersion == OpenApiSpecVersion.OpenApi2_0)
{
Assert.NotNull(mediaType.Schema);
Assert.Null(mediaType.Schema.AnyOf);
Assert.NotNull(mediaType.Schema.Reference);
Assert.Equal("Microsoft.OData.Service.Sample.TrippinInMemory.Models.Person", mediaType.Schema.Reference.Id);
}
else
{
Assert.NotNull(mediaType.Schema);
Assert.Null(mediaType.Schema.Reference);
Assert.NotNull(mediaType.Schema.AnyOf);
var anyOf = Assert.Single(mediaType.Schema.AnyOf);
Assert.Equal("Microsoft.OData.Service.Sample.TrippinInMemory.Models.Person", anyOf.Reference.Id);
}
}
/// <summary>
/// Create the <see cref="OpenApiResponses"/> for a <see cref="IEdmOperationImport"/>
/// </summary>
/// <param name="context">The OData context.</param>
/// <param name="operationImport">The Edm operation import.</param>
/// <returns>The created <see cref="OpenApiResponses"/>.</returns>
public static OpenApiResponses CreateResponses(this ODataContext context, IEdmOperationImport operationImport)
{
Utils.CheckArgumentNull(context, nameof(context));
Utils.CheckArgumentNull(operationImport, nameof(operationImport));
return(context.CreateResponses(operationImport.Operation));
}
public void CanSerializeAsJsonFromTheCreatedResponses()
{
// Arrange
IEdmModel model = EdmCoreModel.Instance;
ODataContext context = new ODataContext(model);
// Act
var responses = context.CreateResponses();
// Assert
var response = responses["error"];
Assert.NotNull(response);
string json = response.SerializeAsJson(OpenApiSpecVersion.OpenApi3_0);
Assert.Equal(@"{
""description"": ""error"",
""content"": {
""application/json"": {
""schema"": {
""$ref"": ""#/components/schemas/ODataErrors.ODataError""
}
}
}
}".ChangeLineBreaks(), json);
}
public void CreateResponseForEdmActionWhenErrorResponsesAsDefaultIsSet(string actionName, bool errorAsDefault, string responseCode)
{
// Arrange
IEdmModel model = EdmModelHelper.GraphBetaModel;
var settings = new OpenApiConvertSettings
{
ErrorResponsesAsDefault = errorAsDefault,
};
ODataContext context = new ODataContext(model, settings);
// Act
OpenApiResponses responses;
IEdmOperation operation = model.SchemaElements.OfType <IEdmOperation>().First(o => o.Name == actionName);
Assert.NotNull(operation); // guard
ODataPath path = new(new ODataOperationSegment(operation));
responses = context.CreateResponses(operation, path);
// Assert
Assert.NotNull(responses);
Assert.NotEmpty(responses);
if (errorAsDefault)
{
Assert.Equal(new string[] { responseCode, "default" }, responses.Select(r => r.Key));
}
else
{
Assert.Equal(new string[] { responseCode, "4XX", "5XX" }, responses.Select(r => r.Key));
}
}
public void CreateResponsesThrowArgumentNullContext()
{
// Arrange
ODataContext context = null;
// Act & Assert
Assert.Throws <ArgumentNullException>("context", () => context.CreateResponses());
}
public void CreateResponseForOperationThrowArgumentNullOperation()
{
// Arrange
ODataContext context = new ODataContext(EdmCoreModel.Instance);
// Act & Assert
Assert.Throws <ArgumentNullException>("operation", () => context.CreateResponses(operation: null));
}
public void CreateResponseForOperationThrowArgumentNullContext()
{
// Arrange
ODataContext context = null;
// Act & Assert
Assert.Throws <ArgumentNullException>("context", () => context.CreateResponses(operation: null, path: null));
}
public void CreateResponseForOperationThrowArgumentNullPath()
{
// Arrange
ODataContext context = new ODataContext(EdmCoreModel.Instance);
EdmFunction function = new EdmFunction("NS", "MyFunction", EdmCoreModel.Instance.GetString(false));
EdmFunctionImport functionImport = new EdmFunctionImport(new EdmEntityContainer("NS", "Default"), "MyFunctionImport", function);
// Act & Assert
Assert.Throws <ArgumentNullException>("path", () => context.CreateResponses(operation: function, path: null));
}
public void CreateResponsesReturnsCreatedResponses()
{
// Arrange
IEdmModel model = EdmCoreModel.Instance;
ODataContext context = new ODataContext(model);
// Act
var responses = context.CreateResponses();
// Assert
Assert.NotNull(responses);
Assert.NotEmpty(responses);
var response = Assert.Single(responses);
Assert.Equal("error", response.Key);
Assert.NotNull(response.Value.Content);
Assert.Single(response.Value.Content);
Assert.Equal("application/json", response.Value.Content.First().Key);
}
/// <summary>
/// Create a <see cref="OpenApiComponents"/>.
/// The value of components is a Components Object.
/// It holds maps of reusable schemas describing message bodies, operation parameters, and responses.
/// </summary>
/// <param name="context">The OData to Open API context.</param>
/// <returns>The created <see cref="OpenApiComponents"/> object.</returns>
public static OpenApiComponents CreateComponents(this ODataContext context)
{
Utils.CheckArgumentNull(context, nameof(context));
// "components": {
// "schemas": …,
// "parameters": …,
// "responses": …,
// "requestBodies": …
// }
return(new OpenApiComponents
{
// The value of schemas is a map of Schema Objects.
// Each entity type, complex type, enumeration type, and type definition directly
// or indirectly used in the paths field is represented as a name/value pair of the schemas map.
Schemas = context.CreateSchemas(),
// The value of parameters is a map of Parameter Objects.
// It allows defining query options and headers that can be reused across operations of the service.
Parameters = context.CreateParameters(),
// The value of responses is a map of Response Objects.
// It allows defining responses that can be reused across operations of the service.
Responses = context.CreateResponses(),
// The value of requestBodies is a map of RequestBody Objects.
// It allows refining request bodies that can be reused across operations of the service.
RequestBodies = context.CreateRequestBodies(),
Examples = context.CreateExamples(),
SecuritySchemes = context.CreateSecuritySchemes(),
// Make others as null.
Links = null,
Callbacks = null,
Extensions = null
});
}
